home *** CD-ROM | disk | FTP | other *** search
/ Macwelt 4 / Macwelt DVD 4.cdr / Entwickler / Mac-OS X / Pantomime / Source / Message.m / Message.m
Encoding:
Text File  |  2002-08-08  |  40.6 KB  |  1,835 lines
  1. /*
  2. **  Message.m
  3. **
  4. **  Copyright (c) 2001, 2002
  5. **
  6. **  Author: Ludovic Marcotte <ludovic@Sophos.ca>
  7. **
  8. **  This library is free software; you can redistribute it and/or
  9. **  modify it under the terms of the GNU Lesser General Public
  10. **  License as published by the Free Software Foundation; either
  11. **  version 2.1 of the License, or (at your option) any later version.
  12. **  
  13. **  This library is distributed in the hope that it will be useful,
  14. **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16. **  Lesser General Public License for more details.
  17. **  
  18. **  You should have received a copy of the GNU Lesser General Public
  19. **  License along with this library; if not, write to the Free Software
  20. **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21. */
  22. #import <Pantomime/Message.h>
  23.  
  24. #import <Pantomime/Constants.h>
  25. #import <Pantomime/Folder.h>
  26. #import <Pantomime/NSStringExtensions.h>
  27. #import <Pantomime/NSDataExtensions.h>
  28.  
  29. #include <time.h>
  30.  
  31. @implementation Message
  32.  
  33. //
  34. //
  35. //
  36. - (id) init
  37. {
  38.   self = [super init];
  39.   
  40.   // We initialize our recipiens array
  41.   recipients = [[NSMutableArray alloc] init];
  42.  
  43.   // We initialize our dictionary that will hold all our headers
  44.   // We initialize it with a capacity of 25. This is a empirical number 
  45.   // that is used to speedup the addition of headers w/o reallocating
  46.   // our array everytime we add a new element.
  47.   headers = [[NSMutableDictionary alloc] initWithCapacity: 25];
  48.   
  49.   // We initialize our headers with some basic values in case they are missing in the messages we decode
  50.   [headers setObject: @"text/plain" forKey: @"Content-Type"];
  51.  
  52.   // FIXME: Should we always initialize with RECENT? or just nothing?
  53.   flags = [[Flags alloc] initWithFlags: RECENT];
  54.  
  55.   // By default, we want the subclass's rawSource method to be called so we set our
  56.   // rawSource ivar to nil. If it's not nil (ONLY set in initWithString), it'll be returned.
  57.   // for performances improvements.
  58.   rawSource = nil;
  59.  
  60.   // We initialize our dictionary holding all extra properties a message might have
  61.   extraProperties = [[NSMutableDictionary alloc] init];
  62.   
  63.   // Initially, we don't have any references
  64.   [self setReferences: nil];
  65.   
  66.  
  67.   [self setInitialized: NO];
  68.   [self setSize: 0];
  69.  
  70.   return self;
  71. }
  72.  
  73.  
  74. //
  75. //
  76. //
  77. - (id) initWithData: (NSData *) theData
  78. {
  79.   NSRange aRange;
  80.  
  81.   aRange = [theData rangeOfCString: "\n\n"];
  82.  
  83.   if (aRange.length == 0)
  84.     {
  85.       NSDebugLog(@"Message: failed to initialize message from data.");
  86.       AUTORELEASE(self);
  87.       return nil;
  88.     }
  89.   
  90.   // We initialize our message with the headers and the content
  91.   self = [self init];
  92.   
  93.   [self setHeadersFromData: [theData subdataWithRange: NSMakeRange(0,aRange.location)]];
  94.   [self setContentFromRawSource:
  95.         [theData subdataWithRange:
  96.                NSMakeRange(aRange.location + 2, [theData length]-(aRange.location+2))]];
  97.   
  98.  
  99.   //
  100.   // We can tell now that this message is fully initialized
  101.   // NOTE: We must NOT call [self setInitialize: YES] since
  102.   //       it will call the method from the subclass and may do
  103.   //       extremely weird things.
  104.   initialized = YES;
  105.  
  106.   // We set our rawSource ivar for performances reason
  107.   [self setRawSource: theData];
  108.  
  109.   return self;
  110. }
  111.  
  112.  
  113. //
  114. //
  115. //
  116. - (id) initWithData: (NSData *) theData
  117.         charset: (NSString *) theCharset
  118. {
  119.   [self setDefaultCharset: theCharset];
  120.  
  121.   return [self initWithData: theData];
  122. }
  123.  
  124.  
  125. //
  126. //
  127. //
  128. - (id) initWithHeadersFromData: (NSData *) theHeaders
  129. {
  130.   self = [self init];
  131.  
  132.   [self setHeadersFromData: theHeaders];
  133.  
  134.   return self;
  135. }
  136.  
  137.  
  138. //
  139. //
  140. //
  141. - (id) initWithHeaders: (NSDictionary *) theHeaders
  142. {
  143.   self = [self init];
  144.   
  145.   [self setHeaders: theHeaders];
  146.   
  147.   return self;
  148. }
  149.  
  150.  
  151. //
  152. //
  153. //
  154. - (void) dealloc
  155. {
  156.   //NSDebugLog(@"Message: -dealloc");
  157.  
  158.   RELEASE(recipients);
  159.   RELEASE(headers);
  160.   RELEASE(flags);
  161.  
  162.   RELEASE(extraProperties);
  163.   
  164.   RELEASE(references);
  165.  
  166.   TEST_RELEASE(rawSource);
  167.   
  168.   [super dealloc];
  169. }
  170.  
  171.  
  172. //
  173. // NSCoding protocol
  174. //
  175. - (void) encodeWithCoder: (NSCoder *) theCoder
  176. {
  177.   [super encodeWithCoder: theCoder];
  178.  
  179.   [theCoder encodeObject: [self recipients]];
  180.   [theCoder encodeObject: [self allHeaders]];
  181.   [theCoder encodeObject: [NSNumber numberWithInt: [self messageNumber]]];
  182.   [theCoder encodeObject: [self flags]];
  183. }
  184.  
  185.  
  186. //
  187. //
  188. //
  189. - (id) initWithCoder: (NSCoder *) theCoder
  190. {
  191.   self = [super init];
  192.   
  193.   [super initWithCoder: theCoder];
  194.  
  195.   [self setRecipients: [theCoder decodeObject]];
  196.   [self setHeaders: [theCoder decodeObject]];
  197.   [self setMessageNumber: [[theCoder decodeObject] intValue]];
  198.   [self setFlags: [theCoder decodeObject]];
  199.  
  200.   // It's very important to set this ivar to NO since we don't serialize the content
  201.   // or our message.
  202.   initialized = NO;
  203.  
  204.   // We initialize the rest of our ivars
  205.   folder = nil;
  206.   rawSource = nil;
  207.  
  208.   // We initialize our dictionary holding all extra properties a message might have
  209.   extraProperties = [[NSMutableDictionary alloc] init];
  210.  
  211.   return self;
  212. }
  213.  
  214.  
  215. //
  216. //
  217. //
  218. - (InternetAddress *) from
  219. {
  220.   return [headers objectForKey: @"From"];
  221. }
  222.  
  223.  
  224. //
  225. //
  226. //
  227. - (void) setFrom: (InternetAddress *) theInternetAddress
  228. {
  229.   [headers setObject: theInternetAddress
  230.        forKey: @"From"];
  231. }
  232.  
  233.  
  234. //
  235. //
  236. //
  237. - (int) messageNumber
  238. {
  239.   return messageNumber;
  240. }
  241.  
  242.  
  243. //
  244. //
  245. //
  246. - (void) setMessageNumber: (int) theMessageNumber
  247. {
  248.   messageNumber = theMessageNumber;
  249. }
  250.  
  251.  
  252. //
  253. //
  254. //
  255. - (NSString *) messageID
  256. {
  257.   return [headers objectForKey: @"Message-ID"];
  258. }
  259.  
  260.  
  261. //
  262. //
  263. //
  264. - (void) setMessageID: (NSString *) theMessageID
  265. {
  266.   [headers setObject: theMessageID
  267.        forKey: @"Message-ID"];
  268. }
  269.  
  270.  
  271. //
  272. //
  273. //
  274. - (NSCalendarDate *) receivedDate
  275. {
  276.   return [headers objectForKey: @"Date"];
  277. }
  278.  
  279.  
  280. //
  281. //
  282. //
  283. - (void) setReceivedDate: (NSCalendarDate*) theDate
  284. {
  285.   [headers setObject: theDate 
  286.        forKey: @"Date"];
  287. }
  288.  
  289.  
  290. //
  291. //
  292. //
  293. - (void) addToRecipients: (InternetAddress *) theAddress
  294. {
  295.   if ( theAddress )
  296.     {
  297.       [recipients addObject: theAddress];
  298.     }
  299. }
  300.  
  301.  
  302. //
  303. //
  304. //
  305. - (void) removeFromRecipients: (InternetAddress *) theAddress
  306. {
  307.   if ( theAddress )
  308.     {
  309.       [recipients removeObject: theAddress];
  310.     }
  311. }
  312.  
  313.  
  314. //
  315. //
  316. //
  317. - (NSArray *) recipients
  318. {
  319.   return recipients;
  320. }
  321.  
  322.  
  323. //
  324. //
  325. //
  326. - (void) setRecipients: (NSArray *) theRecipients
  327. {
  328.   if ( theRecipients )
  329.     {
  330.       NSMutableArray *newRecipients;
  331.       
  332.       newRecipients = [NSMutableArray arrayWithArray: theRecipients];
  333.       RELEASE(recipients);
  334.       RETAIN(newRecipients);
  335.       recipients = newRecipients;
  336.     }
  337.   else
  338.     {
  339.       RELEASE(recipients);
  340.       recipients = nil;
  341.     }
  342. }
  343.  
  344.  
  345. //
  346. //
  347. //
  348. - (int) recipientsCount
  349. {
  350.   return [[self recipients] count];
  351. }
  352.  
  353.  
  354. //
  355. //
  356. //
  357. - (void) removeAllRecipients
  358. {
  359.   [recipients removeAllObjects];
  360. }
  361.  
  362.  
  363. //
  364. //
  365. //
  366. - (InternetAddress *) replyTo
  367. {
  368.   return [headers objectForKey: @"Reply-To"];
  369. }
  370.  
  371.  
  372. //
  373. //
  374. //
  375. - (void) setReplyTo: (InternetAddress *) theInternetAddress
  376. {
  377.   if ( theInternetAddress )
  378.     {
  379.       [headers setObject: theInternetAddress
  380.            forKey: @"Reply-To"];
  381.     }
  382.   else
  383.     {
  384.       [headers removeObjectForKey: @"Reply-To"];
  385.     }
  386. }
  387.  
  388.  
  389. //
  390. //
  391. //
  392. - (NSString *) subject
  393. {
  394.   return [headers objectForKey: @"Subject"];
  395. }
  396.  
  397.  
  398. //
  399. //
  400. //
  401. - (void) setSubject: (NSString *) theSubject
  402. {
  403.   [headers setObject: theSubject
  404.          forKey: @"Subject"];
  405. }
  406.  
  407.  
  408. //
  409. //
  410. //
  411. - (BOOL) isInitialized
  412. {
  413.   return initialized;
  414. }
  415.  
  416.  
  417. //
  418. //
  419. //
  420. - (void) setInitialized: (BOOL) aBOOL
  421. {
  422.   initialized = aBOOL;
  423. }
  424.  
  425.  
  426. //
  427. // Implementation of the Part protocol follows...
  428. //
  429.  
  430.  
  431. - (NSString *) contentDisposition
  432. {
  433.   return [headers objectForKey: @"Content-Disposition"];
  434. }
  435.  
  436. - (void) setContentDisposition: (NSString *) theContentDisposition
  437. {
  438.   [super setContentDisposition: theContentDisposition];
  439.   
  440.   [headers setObject: theContentDisposition
  441.        forKey: @"Content-Disposition"];
  442. }
  443.  
  444. //
  445. //
  446. //
  447. - (NSString *) contentID
  448. {
  449.   return [headers objectForKey: @"Content-Id"];
  450. }        
  451.  
  452.  
  453. //
  454. //
  455. //
  456. - (void) setContentID: (NSString *) theContentID
  457. { 
  458.   [super setContentID: theContentID];
  459.   [headers setObject: theContentID
  460.        forKey: @"Content-Id"];
  461. }  
  462.  
  463.  
  464. //
  465. //
  466. //
  467. - (NSString *) contentType
  468. {
  469.   return [headers objectForKey: @"Content-Type"];
  470. }
  471.  
  472.  
  473. //
  474. //
  475. //
  476. - (void) setContentType: (NSString*) theContentType
  477. {
  478.   [super setContentType: theContentType];
  479.   
  480.   [headers setObject: theContentType
  481.        forKey: @"Content-Type"];
  482. }
  483.  
  484. //
  485. // See RFC1521 (MIME) for more details.
  486. // The Content-Type MUST be defined BEFORE calling this function otherwise
  487. // the content will be considered as a pure string.
  488. //
  489. - (void) setContentFromRawSource: (NSData *) theData
  490. {
  491.   [MimeUtility setContentFromRawSource: theData
  492.            inPart: self];
  493. }
  494.  
  495. //
  496. //
  497. //
  498. - (NSString *) organization
  499. {
  500.   return [headers objectForKey: @"Organization"];
  501. }
  502.  
  503.  
  504. //
  505. //
  506. //
  507. - (void) setOrganization: (NSString *) theOrganization
  508. {
  509.   [headers setObject: theOrganization
  510.        forKey: @"Organization"];
  511. }
  512.  
  513.  
  514. //
  515. //
  516. //
  517. - (id) extraPropertyForKey: (id) theKey
  518. {
  519.   return [extraProperties objectForKey: theKey];
  520. }
  521.  
  522.  
  523. //
  524. //
  525. //
  526. - (void) setExtraProperty: (id) theProperty
  527.                    forKey: (id) theKey
  528. {
  529.   [extraProperties setObject: theProperty
  530.            forKey: theKey];
  531. }
  532.  
  533.  
  534. //
  535. //
  536. //
  537. - (NSArray *) allReferences
  538. {
  539.   return references;
  540. }
  541.  
  542.  
  543. //
  544. //
  545. //
  546. - (void) setReferences: (NSArray *) theReferences
  547. {
  548.   if ( theReferences )
  549.     {
  550.       RETAIN(theReferences);
  551.       RELEASE(references);
  552.       references = theReferences;
  553.     }
  554.   else
  555.     {
  556.       DESTROY(references);
  557.     }
  558. }
  559.  
  560.  
  561. //
  562. //
  563. //
  564. - (Flags *) flags
  565. {
  566.   return flags;
  567. }
  568.  
  569.  
  570. //
  571. //
  572. //
  573. - (void) setFlags: (Flags*) theFlags
  574. {
  575.   RELEASE(flags);
  576.   flags = RETAIN(theFlags);
  577. }
  578.  
  579.  
  580. //
  581. //
  582. //
  583. - (NSString *) mimeVersion
  584. {
  585.   return [headers objectForKey: @"MIME-Version"];
  586. }
  587.  
  588.  
  589. //
  590. //
  591. //
  592. - (void) setMimeVersion: (NSString *) theMimeVersion
  593. {
  594.   [headers setObject: theMimeVersion
  595.        forKey: @"MIME-Version"];
  596. }
  597.  
  598.  
  599. //
  600. // The message will NOT have a content other than the PLAIN/TEXT one(s).
  601. //
  602. - (Message *) replyWithReplyToAll: (BOOL) flag
  603. {
  604.   InternetAddress *anInternetAddress;
  605.   Message *theMessage;
  606.  
  607.   NSMutableString *aMutableString;
  608.   id aContent;
  609.   int i;
  610.  
  611.   BOOL needsToQuote = NO;
  612.   
  613.   theMessage = [[Message alloc] init];
  614.  
  615.   // We set the subject of our message 
  616.   if ( [[[self subject] lowercaseString] hasPrefix: @"re"] )
  617.     {
  618.       [theMessage setSubject: [self subject] ];
  619.     }
  620.   else 
  621.     {
  622.       [theMessage setSubject: [NSString stringWithFormat: @"Re: %@", [self subject]] ];
  623.     }
  624.  
  625.   // If Reply-To is defined, we use it. Otherwise, we use From:
  626.   if ( [self replyTo] == nil )
  627.     {
  628.       anInternetAddress = [self from];
  629.     }
  630.   else 
  631.     {
  632.       anInternetAddress = [self replyTo];
  633.     }
  634.  
  635.   [anInternetAddress setType: TO];
  636.   [theMessage addToRecipients: anInternetAddress];
  637.   
  638.   // We add our In-Reply-To header
  639.   if ( [self messageID] )
  640.     {
  641.       [theMessage addHeader: @"In-Reply-To"
  642.           withValue: [self messageID]];
  643.     }
  644.   
  645.   // If we reply to all, we add the other recipients
  646.   if ( flag )
  647.     {
  648.       NSEnumerator *anEnumerator;
  649.  
  650.       anEnumerator = [[self recipients] objectEnumerator];
  651.       
  652.       while ((anInternetAddress = [anEnumerator nextObject]))
  653.     {
  654.       [anInternetAddress setType: CC];
  655.       [theMessage addToRecipients: anInternetAddress];
  656.     }
  657.     }
  658.  
  659.   // We finally work on the content of the message
  660.   aMutableString = [[NSMutableString alloc] init];
  661.   [aMutableString appendString: @"On "];
  662.   [aMutableString appendString: [[self receivedDate] description] ];
  663.   [aMutableString appendString: [NSString stringWithFormat:@" %@", [[self from] unicodeStringValue]]];
  664.   [aMutableString appendString: @" wrote:\n\n"];
  665.  
  666.   // We give a default value to aContent
  667.   aContent = nil;
  668.   
  669.   //
  670.   // We now get the right text part of the message.
  671.   // 
  672.   // If it's a text/enriched or a text/html, we must remove all the
  673.   // formatting codes and keep only the 'real' text contained in that part.
  674.   //
  675.   if ( [self isMimeType: @"text": @"*"] )
  676.     {
  677.       aContent = (NSString *)[self content];
  678.       needsToQuote = YES;
  679.     }
  680.   //
  681.   // If our message only contains the following part types, we cannot
  682.   // represent those in a reply.
  683.   // 
  684.   else if ( [self isMimeType: @"application": @"*"] ||
  685.         [self isMimeType: @"audio": @"*"] ||
  686.         [self isMimeType: @"image": @"*"] || 
  687.         [self isMimeType: @"message": @"*"] ||
  688.         [self isMimeType: @"video": @"*"] )
  689.     {
  690.       aContent = [NSString stringWithString: @"\t[NON-Text Body part not included]"];
  691.       needsToQuote = NO;
  692.     }
  693.   //
  694.   // We have a multipart type. It can be:
  695.   //
  696.   // multipart/appledouble, multipart/alternative, multipart/related,
  697.   // multipart/mixed or even multipart/report.
  698.   //
  699.   // We must search for a text part to use in our reply.
  700.   //
  701.   else if ( [self isMimeType: @"multipart" : @"*"] )
  702.     {
  703.       MimeMultipart *aMimeMultipart;
  704.       MimeBodyPart *aMimeBodyPart;
  705.       
  706.       aMimeMultipart = (MimeMultipart *)[self content];
  707.       
  708.       for (i = 0; i < [aMimeMultipart count]; i++)
  709.     {
  710.       aMimeBodyPart = [aMimeMultipart bodyPartAtIndex: i];
  711.       
  712.       //
  713.       // We do a full verification on the Content-Type since we might
  714.       // have a text/x-{something} like text/x-vcard.
  715.       //
  716.       if ( [aMimeBodyPart isMimeType: @"text" : @"plain"] ||
  717.            [aMimeBodyPart isMimeType: @"text" : @"enriched"] ||
  718.            [aMimeBodyPart isMimeType: @"text" : @"html"] )
  719.         {
  720.           // If our part was base64 encoded, we must convert the 
  721.           // NSData object into a NSString
  722.           if ( [aMimeBodyPart contentTransferEncoding] == BASE64 &&
  723.            [[aMimeBodyPart content] isKindOfClass: [NSData class]] )
  724.         {
  725.           aContent = [[NSString alloc] initWithData: (NSData *)[aMimeBodyPart content]
  726.                            encoding: NSASCIIStringEncoding];
  727.           AUTORELEASE(aContent);
  728.         }
  729.           else
  730.         {
  731.           aContent = (NSString*)[aMimeBodyPart content];
  732.         }
  733.           break;
  734.         }
  735.       //
  736.       // If we have a multipart/alternative contained in our multipart/mixed (or related)
  737.       // we find the text/plain part contained in this multipart/alternative object.
  738.       //
  739.       else if ( [aMimeBodyPart isMimeType: @"multipart" : @"alternative"] )
  740.         {
  741.           MimeMultipart *anOtherMimeMultipart;
  742.           int j;
  743.           
  744.           anOtherMimeMultipart = (MimeMultipart *)[aMimeBodyPart content];
  745.           
  746.           for (j = 0; j < [anOtherMimeMultipart count]; j++)
  747.         {
  748.           aMimeBodyPart = [anOtherMimeMultipart bodyPartAtIndex: i];
  749.           
  750.           if ( [aMimeBodyPart isMimeType: @"text" : @"plain"] ||
  751.                [aMimeBodyPart isMimeType: @"text" : @"enriched"] ||
  752.                [aMimeBodyPart isMimeType: @"text" : @"html"] )
  753.             {
  754.               // If our part was base64 encoded, we must convert the 
  755.               // NSData object into a NSString
  756.               if ( [aMimeBodyPart contentTransferEncoding] == BASE64 )
  757.             {
  758.               aContent = [[NSString alloc] initWithData: (NSData *)[aMimeBodyPart content]
  759.                               encoding: NSASCIIStringEncoding];
  760.               AUTORELEASE(aContent);
  761.             }
  762.               else
  763.             {
  764.               aContent = (NSString *)[aMimeBodyPart content];
  765.             }
  766.               break;
  767.             } 
  768.         }
  769.         } // else if (...)
  770.     }
  771.       
  772.       needsToQuote = YES;
  773.     }
  774.   
  775.   //
  776.   // It was impossible for use to find a text/plain part. Let's
  777.   // inform our user that we can't do anything with this message.
  778.   //
  779.   if ( !aContent || [aContent isKindOfClass: [NSData class]])
  780.     {
  781.       aContent = [NSString stringWithString: @"\t[NON-Text Body part not included]"];
  782.       needsToQuote = NO;
  783.     }
  784.   else
  785.     {
  786.       // We remove the signature
  787.       NSRange aRange;
  788.       
  789.       aRange = [aContent rangeOfString: @"\n-- "
  790.             options: NSBackwardsSearch];
  791.       
  792.       // We found it!
  793.       if ( aRange.length )
  794.     {
  795.       aContent = [aContent substringToIndex: aRange.location];
  796.     }
  797.     }
  798.  
  799.   // We now have our content as string, let's 'quote' it
  800.   if ( aContent && needsToQuote )
  801.     {
  802.       aContent = [MimeUtility unwrapPlainTextString: aContent
  803.                  usingQuoteWrappingLimit: 78];
  804.       [aMutableString appendString: [MimeUtility quotePlainTextString: aContent
  805.                          quoteLevel: 1
  806.                          wrappingLimit: 80]];
  807.     }
  808.   else if (aContent && !needsToQuote)
  809.     {
  810.       [aMutableString appendString: aContent];
  811.     }
  812.   
  813.   [theMessage setContent: aMutableString];
  814.  
  815.   RELEASE(aMutableString);
  816.   
  817.   return AUTORELEASE(theMessage);
  818. }
  819.  
  820.  
  821. //
  822. // The message WILL have a content.
  823. //
  824. - (Message *) forward
  825. {
  826.   NSMutableString *aMutableString;
  827.   Message *theMessage;
  828.  
  829.   theMessage = [[Message alloc] init];
  830.   
  831.   // We set the subject of our message
  832.   [theMessage setSubject: [NSString stringWithFormat:@"%@ (fwd)", [self subject]] ];
  833.  
  834.   // We create our generic forward message header
  835.   aMutableString = [[NSMutableString alloc] init];
  836.   AUTORELEASE(aMutableString);
  837.  
  838.   [aMutableString appendString: @"---------- Forwarded message ----------\n"];
  839.   [aMutableString appendString: @"Date: "];
  840.   [aMutableString appendString: [[self receivedDate] description] ];
  841.   [aMutableString appendString: @"\nFrom: "];
  842.   [aMutableString appendString: [[self from] unicodeStringValue]];
  843.   [aMutableString appendString: @"\nSubject: "];
  844.   [aMutableString appendString: [NSString stringWithFormat:@"%@\n\n", [self subject]] ];
  845.   
  846.   //
  847.   // If our Content-Type is text/plain, we represent it as a it is, otherwise,
  848.   // we currently create a new body part representing the forwarded message.
  849.   //
  850.   if ( [self isMimeType: @"text": @"*"] )
  851.     {
  852.       // Our message is a text/plain one
  853.       if ( [self isMimeType: @"text" : @"plain"] )
  854.     {
  855.       // We set the content of our message
  856.       [aMutableString appendString: (NSString*)[self content]];
  857.       
  858.       // We set the Content-Transfer-Encoding and the Charset to the previous one
  859.       [theMessage setContentTransferEncoding: [self contentTransferEncoding]];
  860.       [theMessage setCharset: [self charset]];
  861.  
  862.       [theMessage setContent: aMutableString];
  863.       [theMessage setSize: [aMutableString length]];
  864.     }
  865.       // Our message is either a text/enriched, text/html or something else (but text/*).
  866.       else
  867.     {
  868.       MimeMultipart *aMimeMultipart;
  869.       MimeBodyPart *aMimeBodyPart;
  870.  
  871.       aMimeMultipart = [[MimeMultipart alloc] init];
  872.     
  873.       // We add our text/plain part (using Part's default initialized values)
  874.       aMimeBodyPart = [[MimeBodyPart alloc] init];
  875.       [aMimeBodyPart setContent: aMutableString];
  876.       [aMimeBodyPart setContentDisposition: @"inline"];
  877.       [aMimeBodyPart setSize: [aMutableString length]];
  878.       [aMimeMultipart addBodyPart: aMimeBodyPart];
  879.       RELEASE(aMimeBodyPart);
  880.       
  881.       // We add our other text part as a attachment
  882.       aMimeBodyPart = [[MimeBodyPart alloc] init];
  883.       [aMimeBodyPart setContentType: [self contentType]];
  884.       [aMimeBodyPart setContent: [self content]];
  885.       [aMimeBodyPart setContentTransferEncoding: [self contentTransferEncoding]];
  886.       [aMimeBodyPart setCharset: [self charset]];
  887.       [aMimeBodyPart setContentDisposition: @"attachment"];
  888.       [aMimeBodyPart setSize: [self size]];
  889.       [aMimeMultipart addBodyPart: aMimeBodyPart];
  890.       RELEASE(aMimeBodyPart);
  891.  
  892.       [theMessage setContent: aMimeMultipart];
  893.       RELEASE(aMimeMultipart);
  894.     }
  895.     }
  896.   //
  897.   // If our Content-Type is a message/rfc822 or any other type like
  898.   // application/*, audio/*, image/* or video/*
  899.   // 
  900.   else if ( [self isMimeType: @"application": @"*"] ||
  901.         [self isMimeType: @"audio": @"*"] ||
  902.         [self isMimeType: @"image": @"*"] || 
  903.         [self isMimeType: @"message": @"*"] ||
  904.         [self isMimeType: @"video": @"*"] )
  905.     {
  906.       MimeMultipart *aMimeMultipart;
  907.       MimeBodyPart *aMimeBodyPart;
  908.       
  909.       aMimeMultipart = [[MimeMultipart alloc] init];
  910.       
  911.       // We add our text/plain part.
  912.       aMimeBodyPart = [[MimeBodyPart alloc] init];
  913.       [aMimeBodyPart setContent: aMutableString];
  914.       [aMimeBodyPart setContentDisposition: @"inline"];
  915.       [aMimeBodyPart setSize: [aMutableString length]];
  916.       [aMimeMultipart addBodyPart: aMimeBodyPart];
  917.       RELEASE(aMimeBodyPart);
  918.       
  919.       // We add our content as an attachment
  920.       aMimeBodyPart = [[MimeBodyPart alloc] init];  
  921.       [aMimeBodyPart setContentType: [self contentType]];
  922.       [aMimeBodyPart setContent: [self content]];
  923.       [aMimeBodyPart setContentTransferEncoding: [self contentTransferEncoding]];
  924.       [aMimeBodyPart setContentDisposition: @"attachment"];
  925.       [aMimeBodyPart setCharset: [self charset]];
  926.       [aMimeBodyPart setFilename: [self filename]];
  927.       [aMimeBodyPart setSize: [self size]];
  928.       [aMimeMultipart addBodyPart: aMimeBodyPart];
  929.       RELEASE(aMimeBodyPart);
  930.  
  931.       [theMessage setContent: aMimeMultipart];
  932.       RELEASE(aMimeMultipart);
  933.     }
  934.   //
  935.   // We have a multipart object. We must treat multipart/alternative
  936.   // parts differently since we don't want to include multipart parts in the forward.
  937.   //
  938.   else if ( [self isMimeType: @"multipart" : @"*"] )
  939.     {
  940.       //
  941.       // If we have multipart/alternative part, we only keep one part from it.
  942.       //
  943.       if ( [self isMimeType: @"multipart" : @"alternative"] )
  944.     {
  945.       MimeMultipart *aMimeMultipart;
  946.       MimeBodyPart *aMimeBodyPart;
  947.       int i;
  948.       
  949.       aMimeMultipart = (MimeMultipart *)[self content];
  950.       aMimeBodyPart = nil;
  951.  
  952.       // We search for our text/plain part
  953.       for (i = 0; i < [aMimeMultipart count]; i++)
  954.         {
  955.           aMimeBodyPart = [aMimeMultipart bodyPartAtIndex: i];
  956.  
  957.           if ( [aMimeBodyPart isMimeType: @"text": @"plain"] )
  958.         {
  959.           break;
  960.         }
  961.           else
  962.         {
  963.           aMimeBodyPart = nil;
  964.         }
  965.         }
  966.  
  967.       // We found one
  968.       if ( aMimeBodyPart )
  969.         {
  970.           NSString *aString;
  971.           
  972.           // If our part was base64 encoded, we must convert the 
  973.           // NSData object into a NSString
  974.           if ( [aMimeBodyPart contentTransferEncoding] == BASE64 &&
  975.            [[aMimeBodyPart content] isKindOfClass: [NSData class]] )
  976.         {
  977.           aString = [[NSString alloc] initWithData: (NSData *)[aMimeBodyPart content]
  978.                           encoding: NSASCIIStringEncoding];
  979.           AUTORELEASE(aString);
  980.         }
  981.           else
  982.         {
  983.           aString = (NSString*)[aMimeBodyPart content];
  984.         }
  985.  
  986.           // We set the content of our message
  987.           [aMutableString appendString: aString];
  988.           
  989.           // We set the Content-Transfer-Encoding and the Charset to our text part
  990.           [theMessage setContentTransferEncoding: [aMimeBodyPart contentTransferEncoding]];
  991.           [theMessage setCharset: [aMimeBodyPart charset]];
  992.           
  993.           [theMessage setContent: aMutableString];
  994.           [theMessage setSize: [aMutableString length]];
  995.         }
  996.       // We haven't found one! Inform the user that it happened.
  997.       else
  998.         {
  999.           [aMutableString appendString: @"No text/plain part from this multipart/alternative part has been found"];
  1000.           [aMutableString appendString: @"\nNo parts have been included as attachments with this mail during the forward operation."];
  1001.           [aMutableString appendString: @"\n\nPlease report this as a bug."];
  1002.  
  1003.           [theMessage setContent: aMutableString];
  1004.           [theMessage setSize: [aMutableString length]];
  1005.         }
  1006.     }
  1007.       //
  1008.       // We surely have a multipart/mixed or multipart/related.
  1009.       // We search for a text/plain part inside our multipart object.
  1010.       // We 'keep' the other parts in a separate new multipart object too
  1011.       // that will become our new content.
  1012.       //
  1013.       else
  1014.     {
  1015.       MimeMultipart *aMimeMultipart, *newMimeMultipart;
  1016.       MimeBodyPart *aMimeBodyPart;
  1017.       BOOL hasFoundTextPlain = NO;
  1018.       int i;
  1019.       
  1020.       // We get our current mutipart object
  1021.       aMimeMultipart = (MimeMultipart *)[self content];
  1022.  
  1023.       // We create our new multipart object for holding all our parts.
  1024.       newMimeMultipart = [[MimeMultipart alloc] init];
  1025.       
  1026.       for (i = 0; i < [aMimeMultipart count]; i++)
  1027.         {
  1028.           aMimeBodyPart = [aMimeMultipart bodyPartAtIndex: i];
  1029.           
  1030.           if ( [aMimeBodyPart isMimeType: @"text": @"plain"] 
  1031.            && !hasFoundTextPlain )
  1032.         {
  1033.           MimeBodyPart *newMimeBodyPart;
  1034.           
  1035.           newMimeBodyPart = [[MimeBodyPart alloc] init];
  1036.           
  1037.           // We set the content of our new part
  1038.           [aMutableString appendString: (NSString*)[aMimeBodyPart content]];
  1039.           [newMimeBodyPart setContent: aMutableString];
  1040.           [newMimeBodyPart setSize: [aMutableString length]];
  1041.           
  1042.           // We set the Content-Transfer-Encoding and the Charset to the previous one
  1043.           [newMimeBodyPart setContentTransferEncoding: [aMimeBodyPart contentTransferEncoding]];
  1044.           [newMimeBodyPart setCharset: [aMimeBodyPart charset]];
  1045.           
  1046.           // We finally add our new part to our MIME multipart object
  1047.           [newMimeMultipart addBodyPart: newMimeBodyPart];
  1048.           RELEASE(newMimeBodyPart);
  1049.           
  1050.           hasFoundTextPlain = YES;
  1051.         }
  1052.           // We set the Content-Disposition to "attachment"
  1053.           // all the time.
  1054.           else
  1055.         {
  1056.           [aMimeBodyPart setContentDisposition: @"attachment"];
  1057.           [newMimeMultipart addBodyPart: aMimeBodyPart];
  1058.         }
  1059.         }
  1060.       
  1061.       [theMessage setContent: newMimeMultipart];
  1062.       RELEASE(newMimeMultipart);
  1063.     }
  1064.     }
  1065.   //
  1066.   // We got an unknown part. Let's inform the user about this situation.
  1067.   //
  1068.   else
  1069.     {
  1070.       // We set the content of our message
  1071.       [aMutableString appendString: @"The original message contained an unknown part that was not included in this forward message."];
  1072.       [aMutableString appendString: @"\n\nPlease report this as a bug."];
  1073.       
  1074.       [theMessage setContent: aMutableString];
  1075.       [theMessage setSize: [aMutableString length]];
  1076.     }
  1077.   
  1078.   return AUTORELEASE(theMessage);
  1079. }
  1080.  
  1081.  
  1082. //
  1083. //
  1084. //
  1085. - (NSData *) dataUsingSendingMode : (int) theMode
  1086. {
  1087.   NSMutableData *aMutableData;
  1088.   NSDictionary *aLocale;
  1089.  
  1090.   NSEnumerator *allHeaderKeyEnumerator;
  1091.   NSString *aKey;
  1092.  
  1093.   NSCalendarDate *aCalendarDate;
  1094.  
  1095.   NSData *aBoundary, *aData;
  1096.  
  1097.   char *lineTerminator;
  1098.  
  1099.  
  1100.   if ( theMode == SEND_USING_SMTP )
  1101.     {
  1102.       lineTerminator = CRLF;
  1103.     }
  1104.   else
  1105.     {
  1106.       lineTerminator = LF;
  1107.     }
  1108.  
  1109.   // We get our locale in English
  1110. #ifndef MACOSX
  1111.   aLocale = [NSDictionary dictionaryWithContentsOfFile: [NSBundle pathForGNUstepResource: @"English"
  1112.                                   ofType: nil
  1113.                                   inDirectory: @"Resources/Languages"] ];
  1114. #else
  1115.   aLocale = [NSDictionary dictionaryWithContentsOfFile: [[NSBundle bundleForClass:[NSObject class]]
  1116.                               pathForResource: @"English"
  1117.                               ofType: nil
  1118.                               inDirectory: @"Languages"] ];
  1119. #endif
  1120.   
  1121.   // We initialize our mutable data object holding the raw data of the
  1122.   // new message.
  1123.   aMutableData = [[NSMutableData alloc] init];
  1124.   
  1125.   aBoundary = [MimeUtility generateBoundary];
  1126.   
  1127.   // If we're sending this message to a local folder, we must append the From - tag.
  1128.   if ( theMode == SEND_TO_FOLDER )
  1129.     {
  1130.       [aMutableData appendCFormat: @"From -\n"];
  1131.     }
  1132.  
  1133. #ifndef MACOSX
  1134.   tzset();
  1135.  
  1136.   aCalendarDate = [[[NSDate alloc] init] dateWithCalendarFormat:@"%a, %d %b %Y %H:%M:%S %z"
  1137.                      timeZone: [NSTimeZone timeZoneWithAbbreviation: 
  1138.                                  [NSString stringWithCString: tzname[1]]] ];
  1139. #else
  1140.   aCalendarDate = [[[NSDate alloc] init] dateWithCalendarFormat:@"%a, %d %b %Y %H:%M:%S %z"
  1141.                      timeZone: [NSTimeZone systemTimeZone] ];
  1142. #endif
  1143.   [aMutableData appendCFormat: @"Date: %@%s", [aCalendarDate descriptionWithLocale: aLocale],
  1144.         lineTerminator];
  1145.   
  1146.   // We set the subject, if we have one!
  1147.   if ( [[[self subject] stringByTrimmingWhiteSpaces] length] > 0 )
  1148.     {
  1149.       [aMutableData appendCString: "Subject: "];
  1150.       [aMutableData appendData: [MimeUtility encodeWordUsingQuotedPrintable: [self subject]
  1151.                                       prefixLength: 8]];
  1152.       [aMutableData appendCString: lineTerminator];
  1153.     }
  1154.   
  1155.   // We set our Message-ID
  1156.   [aMutableData appendCFormat:@"Message-ID: <"];
  1157.   [aMutableData appendData: [MimeUtility generateOSID]];
  1158.   [aMutableData appendCFormat: @">%s", lineTerminator];
  1159.   
  1160.   [aMutableData appendCFormat: @"MIME-Version: 1.0 (Generated by Pantomime %@)%s", PANTOMIME_VERSION, lineTerminator];
  1161.  
  1162.   // We encode our From: field
  1163.   [aMutableData appendCFormat: @"From: "];
  1164.   [aMutableData appendData: [[self from] dataValue]];
  1165.   [aMutableData appendCFormat: @"%s",lineTerminator];
  1166.   
  1167.   // We encode our To field
  1168.   aData = [self _formatRecipientsWithType: TO];
  1169.   
  1170.   if ( aData )
  1171.     {
  1172.       [aMutableData appendCString: "To: "];
  1173.       [aMutableData appendData: aData];
  1174.       [aMutableData appendCString: lineTerminator];
  1175.     }
  1176.  
  1177.   // We encode our Cc field
  1178.   aData = [self _formatRecipientsWithType: CC];
  1179.   
  1180.   if ( aData )
  1181.     {
  1182.       [aMutableData appendCString: "Cc: "];
  1183.       [aMutableData appendData: aData];
  1184.       [aMutableData appendCString: lineTerminator];
  1185.     }
  1186.  
  1187.   // We encode our Bcc field
  1188.   aData = [self _formatRecipientsWithType: BCC];
  1189.   
  1190.   if ( aData )
  1191.     {
  1192.       [aMutableData appendCString: "Bcc: "];
  1193.       [aMutableData appendData: aData];
  1194.       [aMutableData appendCString: lineTerminator];
  1195.     }
  1196.   
  1197.   // We set the Reply-To address in case we need to
  1198.   if ( [self replyTo] )
  1199.     {
  1200.       [aMutableData appendCFormat: @"Reply-To: "];
  1201.       [aMutableData appendData: [[self replyTo] dataValue]];
  1202.       [aMutableData appendCFormat: @"%s",lineTerminator];
  1203.     }
  1204.   
  1205.   // We set the Organization header value if we need to
  1206.   // FIXME: Should we quote this value?
  1207.   if ( [self organization] )
  1208.     {
  1209.       [aMutableData appendCFormat:@"Organization: %@%s", [self organization], lineTerminator];
  1210.     }
  1211.   
  1212.   // We set the In-Reply-To header if we need to
  1213.   if ( [self headerValueForName: @"In-Reply-To"] )
  1214.     {
  1215.       [aMutableData appendCFormat:@"In-Reply-To: %@%s", [self headerValueForName: @"In-Reply-To"], lineTerminator];
  1216.     }
  1217.   
  1218.  
  1219.   // We now set all X-* headers
  1220.   allHeaderKeyEnumerator = [[self allHeaders] keyEnumerator];
  1221.   
  1222.   while ( (aKey = [allHeaderKeyEnumerator nextObject]) ) 
  1223.     {
  1224.       if ( [aKey hasPrefix: @"X-"] )
  1225.     {
  1226.       [aMutableData appendCFormat:@"%@: %@%s", aKey, [self headerValueForName: aKey], lineTerminator];
  1227.     }
  1228.     }
  1229.   
  1230.   //
  1231.   // We add our message header/body separator
  1232.   //
  1233.   [aMutableData appendData: [super dataUsingSendingMode: theMode]];
  1234.  
  1235.   return AUTORELEASE(aMutableData);
  1236. }
  1237.  
  1238.  
  1239. //
  1240. // This method is used to add an extra header to the list of headers
  1241. // of the message.
  1242. //
  1243. - (void) addHeader: (NSString *) theName
  1244.      withValue: (NSString *) theValue
  1245. {
  1246.   [headers setObject: theValue forKey: theName];
  1247. }
  1248.  
  1249.  
  1250. - (id) headerValueForName: (NSString *) theName
  1251. {
  1252.   return [headers objectForKey: theName];
  1253. }
  1254.  
  1255. - (NSDictionary *) allHeaders
  1256. {
  1257.   return headers;
  1258. }
  1259.  
  1260. - (Folder *) folder
  1261. {
  1262.   return folder;
  1263. }
  1264.  
  1265. - (void) setFolder: (Folder *) theFolder
  1266. {
  1267.   folder = theFolder;
  1268. }
  1269.  
  1270.  
  1271. //
  1272. // This method initalize all the headers of a message
  1273. // from a raw data source.
  1274. //
  1275. // FIXME: Should we move most of the 'parsing' to the
  1276. // Parser class?
  1277. //
  1278. - (void) setHeadersFromData: (NSData *) theHeaders
  1279. {
  1280.   NSAutoreleasePool *pool;
  1281.   NSArray *allLines;
  1282.   int i;
  1283.   
  1284.   if (!theHeaders || [theHeaders length] == 0)
  1285.     {
  1286.       return;
  1287.     }
  1288.  
  1289.   // We initialize a local autorelease pool
  1290.   pool = [[NSAutoreleasePool alloc] init];
  1291.  
  1292.   // We MUST be sure to unfold all headers properly before
  1293.   // decoding the headers
  1294.   theHeaders = [MimeUtility unfoldLinesFromData: theHeaders];
  1295.  
  1296.   allLines = [theHeaders componentsSeparatedByCString: "\n"];
  1297.  
  1298.   for (i = 0; i < [allLines count]; i++)
  1299.     {
  1300.       NSData *aLine = [allLines objectAtIndex: i];
  1301.  
  1302.       // We stop if we found the header separator. (\n\n) since someone could
  1303.       // have called this method with the entire rawsource of a message.
  1304.       if ( [aLine length]==0 )
  1305.     {
  1306.       break;
  1307.     }
  1308.  
  1309.       if ([aLine hasCaseInsensitiveCPrefix: "Bcc"])
  1310.     {
  1311.       [Parser parseDestination:aLine
  1312.           forType:BCC
  1313.           inMessage:self];
  1314.     }
  1315.       else if ([aLine hasCaseInsensitiveCPrefix: "Cc"])
  1316.     {
  1317.       [Parser parseDestination:aLine
  1318.           forType:CC
  1319.           inMessage:self];
  1320.     }
  1321.       else if ([aLine hasCaseInsensitiveCPrefix: "Content-Disposition"])
  1322.     {
  1323.       [Parser parseContentDisposition:aLine inPart:self];
  1324.     }
  1325.       else if ([aLine hasCaseInsensitiveCPrefix: "Content-Transfer-Encoding"])
  1326.     {
  1327.       [Parser parseContentTransferEncoding:aLine inPart:self];
  1328.     }
  1329.       else if ([aLine hasCaseInsensitiveCPrefix: "Content-Type"])
  1330.     {
  1331.       [Parser parseContentType:aLine inPart:self];
  1332.     }
  1333.       else if ([aLine hasCaseInsensitiveCPrefix: "Date"])
  1334.     {
  1335.       [Parser parseDate:aLine inMessage:self];
  1336.     }
  1337.       else if ( [aLine hasCaseInsensitiveCPrefix: "From"] &&
  1338.         ![aLine hasCaseInsensitiveCPrefix: "From -"] )
  1339.     {
  1340.       [Parser parseFrom:aLine inMessage:self];
  1341.     }
  1342.       else if ([aLine hasCaseInsensitiveCPrefix: "Message-ID"])
  1343.     {
  1344.       [Parser parseMessageID:aLine inMessage:self];
  1345.     }
  1346.       else if ([aLine hasCaseInsensitiveCPrefix: "MIME-Version"])
  1347.     {
  1348.       [Parser parseMimeVersion:aLine inMessage:self];
  1349.     }
  1350.       else if ([aLine hasCaseInsensitiveCPrefix: "Organization"])
  1351.     {
  1352.       [Parser parseOrganization:aLine inMessage:self];
  1353.     }
  1354.       else if ([aLine hasCaseInsensitiveCPrefix: "References"])
  1355.     {
  1356.       [Parser parseReferences: aLine 
  1357.           inMessage: self];
  1358.     }
  1359.       else if ([aLine hasCaseInsensitiveCPrefix: "Reply-To"])
  1360.     {
  1361.       [Parser parseReplyTo:aLine inMessage:self];
  1362.     }
  1363.       else if ([aLine hasCaseInsensitiveCPrefix: "Resent-From"])
  1364.     {
  1365.       [Parser parseResentFrom:aLine inMessage:self];
  1366.     }
  1367.       else if ([aLine hasCaseInsensitiveCPrefix: "Resent-Bcc"])
  1368.     {
  1369.       [Parser parseDestination:aLine
  1370.           forType:RESENT_BCC
  1371.           inMessage:self];
  1372.     }
  1373.       else if ([aLine hasCaseInsensitiveCPrefix: "Resent-Cc"])
  1374.     {
  1375.       [Parser parseDestination:aLine
  1376.           forType:RESENT_CC
  1377.           inMessage:self];
  1378.     }
  1379.       else if ([aLine hasCaseInsensitiveCPrefix: "Resent-To"])
  1380.     {
  1381.       [Parser parseDestination:aLine
  1382.           forType:RESENT_TO
  1383.           inMessage:self];
  1384.     }
  1385.       else if ([aLine hasCaseInsensitiveCPrefix: "Status"])
  1386.     {
  1387.       [Parser parseStatus:aLine inMessage:self];
  1388.     }
  1389.       else if ([aLine hasCaseInsensitiveCPrefix: "To"])
  1390.     {
  1391.       [Parser parseDestination:aLine
  1392.           forType:TO
  1393.           inMessage:self];
  1394.     }
  1395.       else if ([aLine hasCaseInsensitiveCPrefix: "X-Status"])
  1396.     {
  1397.       [Parser parseXStatus:aLine inMessage:self];
  1398.     }
  1399.       else if ([aLine hasCaseInsensitiveCPrefix: "Subject"])
  1400.     {
  1401.       [Parser parseSubject:aLine inMessage:self];
  1402.     }
  1403.       else
  1404.     {
  1405.       [Parser parseUnknownHeader:aLine inMessage:self];
  1406.     }
  1407.     }
  1408.  
  1409.   RELEASE(pool);
  1410. }
  1411.  
  1412. //
  1413. //
  1414. //
  1415. - (void) setHeaders: (NSDictionary *) theHeaders
  1416. {
  1417.   RELEASE(headers);
  1418.   
  1419.   headers = [[NSMutableDictionary alloc] initWithCapacity: [theHeaders count]];
  1420.   [headers addEntriesFromDictionary: theHeaders];
  1421. }
  1422.  
  1423.  
  1424. //
  1425. // This method is used to optain tha raw source of a message.
  1426. // It's returned as a NSData object. The returned data should
  1427. // be the message like it's achived in a mbox format and it could
  1428. // easily be decoded with Message: -initWithData.
  1429. // 
  1430. // All subclasses of Message MUST implement this method.
  1431. //
  1432. - (NSData *) rawSource
  1433. {
  1434.   if ( !rawSource )
  1435.     {
  1436.       [self subclassResponsibility: _cmd];
  1437.       return nil;
  1438.     }
  1439.   
  1440.   return rawSource;
  1441. }
  1442.  
  1443.  
  1444. //
  1445. //
  1446. //
  1447. - (void) setRawSource: (NSData *) theRawSource
  1448. {
  1449.   if ( theRawSource )
  1450.     {
  1451.       RETAIN(theRawSource);
  1452.       RELEASE(rawSource);
  1453.       rawSource = theRawSource;
  1454.     }
  1455.   else
  1456.     {
  1457.       DESTROY(rawSource);
  1458.     }
  1459. }
  1460.  
  1461. //
  1462. //
  1463. //
  1464. - (NSCalendarDate *) resentDate
  1465. {
  1466.   return [headers objectForKey: @"Resent-Date"];
  1467. }
  1468.  
  1469. - (void) setResentDate: (NSCalendarDate *) theResentDate
  1470. {
  1471.   [headers setObject: theResentDate 
  1472.        forKey: @"Resent-Date"];
  1473. }
  1474.  
  1475. - (InternetAddress *) resentFrom
  1476. {
  1477.   return [headers objectForKey: @"Resent-From"];
  1478. }
  1479.  
  1480. - (void) setResentFrom: (InternetAddress *) theInternetAddress
  1481. {
  1482.   [headers setObject: theInternetAddress
  1483.        forKey: @"Resent-From"];
  1484. }
  1485.  
  1486. - (NSString *) resentMessageID
  1487. {
  1488.   return [headers objectForKey: @"Resent-Message-ID"];
  1489. }
  1490.  
  1491. - (void) setResentMessageID: (NSString *) theResentMessageID
  1492. {
  1493.   [headers setObject: theResentMessageID
  1494.        forKey: @"Resent-Message-ID"];
  1495. }
  1496.  
  1497. - (NSString *) resentSubject
  1498. {
  1499.   return [headers objectForKey: @"Resent-Subject"];
  1500. }
  1501.  
  1502. - (void) setResentSubject: (NSString *) theResentSubject
  1503. {
  1504.   [headers setObject: theResentSubject
  1505.        forKey: @"Resent-Subject"];
  1506. }
  1507.  
  1508. @end
  1509.  
  1510.  
  1511. //
  1512. // Message's sorting category
  1513. //
  1514. @implementation Message (Comparing)
  1515.  
  1516. - (int) compareAccordingToNumber: (Message *) aMessage
  1517. {
  1518.   int num1, num2;
  1519.   num1 = [self messageNumber];
  1520.   num2 = [aMessage messageNumber];
  1521.   if (num1 < num2)
  1522.     {
  1523.       return NSOrderedAscending;
  1524.     }
  1525.   else if (num1 > num2)
  1526.     {
  1527.       return NSOrderedDescending;
  1528.     }
  1529.   else
  1530.     {
  1531.       return NSOrderedSame;
  1532.     }
  1533. }
  1534.  
  1535. - (int) reverseCompareAccordingToNumber: (Message *) aMessage
  1536. {
  1537.   int num1, num2;
  1538.   num2 = [self messageNumber];
  1539.   num1 = [aMessage messageNumber];
  1540.   if (num1 < num2)
  1541.     {
  1542.       return NSOrderedAscending;
  1543.     }
  1544.   else if (num1 > num2)
  1545.     {
  1546.       return NSOrderedDescending;
  1547.     }
  1548.   else
  1549.     {
  1550.       return NSOrderedSame;
  1551.     }
  1552. }
  1553.  
  1554. - (int) compareAccordingToDate: (Message *) aMessage
  1555. {
  1556.   NSDate *date1 = [self receivedDate];
  1557.   NSDate *date2 = [aMessage receivedDate];
  1558.   NSTimeInterval timeInterval;
  1559.  
  1560.   if (date1 == nil || date2 == nil)
  1561.     {
  1562.       return [self compareAccordingToNumber: aMessage]; 
  1563.     }
  1564.  
  1565.   timeInterval = [date1 timeIntervalSinceDate: date2];
  1566.  
  1567.   if (timeInterval < 0)
  1568.     {
  1569.       return NSOrderedAscending;
  1570.     }
  1571.   else if (timeInterval > 0)
  1572.     {
  1573.       return NSOrderedDescending;
  1574.     }
  1575.   else
  1576.     {
  1577.       return [self compareAccordingToNumber: aMessage];      
  1578.     }
  1579. }
  1580.  
  1581. - (int) reverseCompareAccordingToDate: (Message *) aMessage
  1582. {
  1583.   NSDate *date2 = [self receivedDate];
  1584.   NSDate *date1 = [aMessage receivedDate];
  1585.   NSTimeInterval timeInterval;
  1586.  
  1587.   if (date1 == nil || date2 == nil)
  1588.     {
  1589.       return [self reverseCompareAccordingToNumber: aMessage]; 
  1590.     }
  1591.  
  1592.   timeInterval = [date1 timeIntervalSinceDate: date2];
  1593.  
  1594.   if (timeInterval < 0)
  1595.     {
  1596.       return NSOrderedAscending;
  1597.     }
  1598.   else if (timeInterval > 0)
  1599.     {
  1600.       return NSOrderedDescending;
  1601.     }
  1602.   else
  1603.     {
  1604.       return [self reverseCompareAccordingToNumber: aMessage];      
  1605.     }
  1606. }
  1607.  
  1608. - (int) compareAccordingToSender: (Message *) aMessage
  1609. {
  1610.   InternetAddress *from1, *from2;
  1611.   NSString *fromString1, *fromString2;
  1612.   NSString *tempString;
  1613.   int result;
  1614.  
  1615.   from1 = [self from];
  1616.   from2 = [aMessage from];
  1617.  
  1618.   tempString = [from1 personal];
  1619.   if (tempString == nil || [tempString length] == 0)
  1620.     {
  1621.       fromString1 = [from1 address];
  1622.       if (fromString1 == nil)
  1623.     fromString1 = @"";
  1624.     }
  1625.   else
  1626.     {
  1627.       fromString1 = tempString;
  1628.     }
  1629.  
  1630.  
  1631.   tempString = [from2 personal];
  1632.   if (tempString == nil || [tempString length] == 0)
  1633.     {
  1634.       fromString2 = [from2 address];
  1635.       if (fromString2 == nil)
  1636.     fromString2 = @"";
  1637.     }
  1638.   else
  1639.     {
  1640.       fromString2 = tempString;
  1641.     }
  1642.  
  1643.   result = [fromString1 caseInsensitiveCompare: fromString2];
  1644.   if (result == NSOrderedSame)
  1645.     {
  1646.       return [self compareAccordingToNumber: aMessage];
  1647.     }
  1648.   else
  1649.     {
  1650.       return result;
  1651.     }
  1652. }
  1653.  
  1654. - (int) reverseCompareAccordingToSender: (Message *) aMessage
  1655. {
  1656.   InternetAddress *from1, *from2;
  1657.   NSString *fromString1, *fromString2;
  1658.   NSString *tempString;
  1659.   int result;
  1660.  
  1661.   from2 = [self from];
  1662.   from1 = [aMessage from];
  1663.  
  1664.   tempString = [from1 personal];
  1665.   if (tempString == nil || [tempString length] == 0)
  1666.     {
  1667.       fromString1 = [from1 address];
  1668.       if (fromString1 == nil)
  1669.     fromString1 = @"";
  1670.     }
  1671.   else
  1672.     {
  1673.       fromString1 = tempString;
  1674.     }
  1675.  
  1676.  
  1677.   tempString = [from2 personal];
  1678.   if (tempString == nil || [tempString length] == 0)
  1679.     {
  1680.       fromString2 = [from2 address];
  1681.       if (fromString2 == nil)
  1682.     fromString2 = @"";
  1683.     }
  1684.   else
  1685.     {
  1686.       fromString2 = tempString;
  1687.     }
  1688.  
  1689.  
  1690.   result = [fromString1 caseInsensitiveCompare: fromString2];
  1691.   
  1692.   if (result == NSOrderedSame)
  1693.     {
  1694.       return [self reverseCompareAccordingToNumber: aMessage];
  1695.     }
  1696.   else
  1697.     {
  1698.       return result;
  1699.     }
  1700. }
  1701.  
  1702. - (int) compareAccordingToSubject: (Message *) aMessage
  1703. {
  1704.   NSString *subject1 = [self subject];
  1705.   NSString *subject2 = [aMessage subject];
  1706.   int result;
  1707.   
  1708.   if (subject1 == nil)
  1709.     subject1 = @"";
  1710.   if (subject2 == nil)
  1711.     subject2 = @"";
  1712.  
  1713.   result = [subject1 caseInsensitiveCompare: subject2];
  1714.  
  1715.   if (result == NSOrderedSame)
  1716.     {
  1717.       return [self compareAccordingToNumber: aMessage];      
  1718.     }
  1719.   else
  1720.     {
  1721.       return result;
  1722.     }
  1723. }
  1724.  
  1725. - (int) reverseCompareAccordingToSubject: (Message *) aMessage
  1726. {
  1727.   NSString *subject2 = [self subject];
  1728.   NSString *subject1 = [aMessage subject];
  1729.   int result;
  1730.   
  1731.   if (subject1 == nil)
  1732.     subject1 = @"";
  1733.   if (subject2 == nil)
  1734.     subject2 = @"";
  1735.  
  1736.   result = [subject1 caseInsensitiveCompare: subject2];
  1737.  
  1738.   if (result == NSOrderedSame)
  1739.     {
  1740.       return [self compareAccordingToNumber: aMessage];      
  1741.     }
  1742.   else
  1743.     {
  1744.       return result;
  1745.     }
  1746. }
  1747.  
  1748. - (int) compareAccordingToSize: (Message *) aMessage
  1749. {
  1750.   int size1 = [self size];
  1751.   int size2 = [aMessage size];
  1752.  
  1753.  
  1754.   if (size1 < size2)
  1755.     {
  1756.       return NSOrderedAscending;
  1757.     }
  1758.   else if (size1 > size2)
  1759.     {
  1760.       return NSOrderedDescending;
  1761.     }
  1762.   else
  1763.     {
  1764.       return [self compareAccordingToNumber: aMessage];
  1765.     }
  1766. }
  1767.  
  1768. - (int) reverseCompareAccordingToSize: (Message *) aMessage
  1769. {
  1770.   int size1 = [aMessage size];
  1771.   int size2 = [self size];
  1772.  
  1773.  
  1774.   if (size1 < size2)
  1775.     {
  1776.       return NSOrderedAscending;
  1777.     }
  1778.   else if (size1 > size2)
  1779.     {
  1780.       return NSOrderedDescending;
  1781.     }
  1782.   else
  1783.     {
  1784.       return [self reverseCompareAccordingToNumber: aMessage];      
  1785.     }
  1786. }
  1787.  
  1788. @end
  1789.  
  1790.  
  1791. //
  1792. // Private methods
  1793. //
  1794. @implementation Message (Private)
  1795.  
  1796. - (NSData *) _formatRecipientsWithType: (int) theType
  1797. {
  1798.   NSMutableData *aMutableData;
  1799.   NSArray *anArray;
  1800.   int i;
  1801.  
  1802.   aMutableData = [[NSMutableData alloc] init];
  1803.   anArray = [self recipients];
  1804.  
  1805.   for (i = 0; i < [anArray count]; i++)
  1806.     {
  1807.       InternetAddress *anInternetAddress;
  1808.  
  1809.       anInternetAddress = [anArray objectAtIndex: i];
  1810.  
  1811.       if ([anInternetAddress type] == theType)
  1812.     {
  1813.       [aMutableData appendData: [anInternetAddress dataValue]];
  1814.       [aMutableData appendCString: ", "];
  1815.     }
  1816.     }
  1817.   
  1818.   if ( [aMutableData length] > 0)
  1819.     {
  1820.       [aMutableData setLength: [aMutableData length] - 2];
  1821.  
  1822.       return AUTORELEASE(aMutableData);
  1823.     }
  1824.   else
  1825.     {
  1826.       RELEASE(aMutableData);
  1827.       
  1828.       return nil;
  1829.     }
  1830. }
  1831.  
  1832. @end
  1833.  
  1834.  
  1835.